home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 2 / CU Amiga Magazine's Super CD-ROM 02 (1996)(EMAP Images)(GB)[!][issue 1996-04].iso / magazine / amiga_e / e_update_v3.2e / easygui / easygui.doc < prev    next >
Text File  |  1994-11-08  |  24KB  |  574 lines
  1. [re-read if you want to use pre-v3.2a code with this release. dig them new PLUGINs!]
  2.  
  3.                               Introducing:
  4.  
  5.                           E A S Y G U I   v3.2e
  6.  
  7.      An interface builder for E, with the following highlights:
  8.  
  9.     - It's totally Font-Sensitive
  10.     - It's Resizable
  11.     - It's Self-Organising, i.e. it arranges gadgets
  12.     - It's more StyleGuide compliant than your granny
  13.     - It's Fast and Flexible
  14.     - It's relatively small, needs no extra external libraries
  15.     - The layout-engine is user-extendable
  16.     - And above all: It's extremely easy to use!!!
  17.  
  18. +---------------------------------------------------------------+
  19. |    0. History                        |
  20. +---------------------------------------------------------------+
  21.  
  22. changes from the v3.2a version:
  23. - now supports PLUGINs for unlimited complex gui's!!! (check section 5)
  24. - added settext() and setnum()
  25. - fixed NUM gadget
  26. - added topaz-fallback version
  27. - bug: rendered into the border when used with sysihack
  28. - bug: could cause enforcer hits when some strings were NIL
  29. - bug: dealocation of resources in wrong order caused problems
  30.  
  31. changes from the v3.1a version:
  32. - new functions to access/modify gadgets while GUI is active
  33. - easily add gadtools menus
  34. - more complete docs
  35. - works better with multiple simultanuous EasyGUIs
  36. - LISTV, MX and CYCLE have an extra "current" parameter now
  37. - STR now takes an _estring_ as value (change this in old sources!)
  38. - bug: current gadget values would reset upon resize
  39. - bug: would open in middle of screen instead of visible part
  40. - many tiny bugs removed
  41.  
  42. +---------------------------------------------------------------+
  43. |    1. EasyGUI Intro                    |
  44. +---------------------------------------------------------------+
  45.  
  46. EasyGUI takes the form a module file that needs to be included into your E
  47. source (needless to say, it needs v2.04/v37 of the OS).  The most simple form
  48. of constructing a GUI consist of calling the function easygui() with a
  49. (possibly nested) E list which describes your GUI.  just to show how Easy, try
  50. this source:
  51.  
  52.     MODULE 'tools/EasyGUI'
  53.     PROC main() IS easygui('um,...',[BUTTON,0,'Ok!'])
  54.  
  55. This'll open a window with just one gadget in it, and wait for the
  56. user to push it. If easygui() can't get what it wants, it'll start
  57. throwing around exceptions, so we'll probably need an exception
  58. handler to be able to inform the user properly (see below).
  59.  
  60. The first arg of easygui() is the window title, the second one is the
  61. GUI description. The form of these desciptions is quite simple: It's a
  62. list with as first element the type of gadget, the second is called an
  63. action value (more later), and the rest is gadget-specific.
  64.  
  65. To be able to build GUI's outof more components than just one gadget,
  66. one can group gadgets with a ROW and a COL list:
  67.  
  68. [COLS,
  69.   [BUTTON,1,'Ok'],
  70.   [BUTTON,0,'Cancel']
  71. ]
  72.  
  73. This'll create a new group, consisting of two gadgets next to each other.
  74. COLS and ROWS groups are like a single gadget, i.e. you can easily put them
  75. into other groups, to create GUI's of infinite complexity.
  76.  
  77. Other Grouping functions are EQCOLS and EQCOLS, which try to align gadgets
  78. in a group. IF you get strange layouts using these, you should try grouping
  79. subgroups before putting them in a larger group.
  80.  
  81. [BEVEL,a] will put a bevel box around a, whatever it is (a gadget, a group...),
  82. and BEVELR is the recessed version.
  83.  
  84. Other elements of groups are mostly gadgets, which have a specific #of
  85. arguments. [If the number of arguments is incorrect, EasyGUI will raise
  86. the "Egui" exception.]
  87.  
  88. The first element is always the type of gadget to create (see below). The
  89. second element is always something called an "actionvalue", which tells
  90. EasyGUI what needs to be done when the user interacts with the gadget.
  91. All elements after that are gadget specific.
  92.  
  93. An action value may be:
  94. - a small positive integer (0-1000). If the user selects this gadget,
  95.   EasyGUI will close the window, and return that value as returnvalue
  96.   from the easygui() call. This is meant for "Ok" / "Cancel" type buttons.
  97. - a pointer to an "action function". If the user selects this gadget,
  98.   EasyGUI will call the function with as arguments depending on the
  99.   type of gadget (for example a slider will get it's current value).
  100.   After the actionfunction returns, EasyGUI continues processing messages
  101.   from the GUI.
  102.   example:
  103.  
  104.     ...[BUTTON,{load},'Load'],...
  105.  
  106.     PROC load(info) IS WriteF('You pushed the "Load" button!\n')
  107.  
  108.   
  109.   the value of `info' is explained below. Or:
  110.  
  111.     DEF s[100]:STRING
  112.  
  113.     ...[STR,{str},'input:',s,50,4],
  114.            [CYCLE,{cycle},'choose:',['Yep','Nope',NIL],1],...
  115.  
  116.     PROC str(info,news) IS WriteF('the new string is: \s\n',news)
  117.     PROC cycle(info,newc) IS WriteF('the new choice is: \d\n',newc)
  118.  
  119.   In the action function, you can store the new value, however EasyGUI keeps
  120.   track of it itself too: In the case of the STR above it will StrCopy() new
  121.   values into your estring, so it automatically has the correct value after
  122.   closing. In the case of all other gadgets it stores the new (integer) value
  123.   in the list (so that `1' in `CYCLE' may become `0'). This has the added
  124.   benefit that windows that are opened and then closed again will automatically
  125.   start with the current values.
  126.  
  127. The easygui() function:
  128.  
  129.     easygui(windowtitle,gui,info=0,screen=0,textattr=0,newmenus=0)
  130.  
  131. `info' may be ANY value, and is always passed as first arg to the
  132.   action functions. For example if you write a prefsrequester, this may
  133.   be the the prefs OBJECT. Your actionfunctions then have a simple task
  134.   changing the value of the element in question.
  135. `screen' is an optional screen ptr to open on. if not present, EasyGUI opens
  136.   on the current public screen.
  137. `textattr' is a fontdescription, and is best left NIL. If NIL, EasyGUI
  138.   will pick the font the user selected as "screenfont" in fontprefs.
  139. `newmenus' can be a newmenus structure (as in gadtools.library). EasyGUI
  140.   will then automatically attach it to the window and arrange any messages.
  141.   You can give the same actionvalues as gadgets in the newmenu.userdata,
  142.   and the actionfunction can be the same as for a `BUTTON', i.e.:
  143.  
  144.     [...,2,0,'Load','l',0,0,{load},...]:newmenu
  145.  
  146.   can use the same load() as in the example further above.
  147.  
  148.  
  149. +---------------------------------------------------------------+
  150. |    2. Gadgets                        |
  151. +---------------------------------------------------------------+
  152.  
  153.  
  154. general format: [NAME,action,text,...]
  155. in {}: which direction it may resize.
  156. * = not implemented or things missing.
  157. + = a value that can be affected lateron with the set#? functions
  158.  
  159. Each gadget shows the gadget template, explanation, the form of the
  160. actionfunction, and a typical example).
  161.  
  162.  
  163. [BUTTON,action,intext]
  164. buttonaction(info)
  165. example: [BUTTON,0,'Cancel']
  166.  
  167. [CHECK,action,righttext,checkedbool+,lefttextbool]
  168. checkedbool = whether gadget should initially be check-marked
  169. checkaction(info,checkedbool)
  170. example: [CHECK,{case},'Ignore case',TRUE,FALSE]
  171.  
  172. [INTEGER,action,lefttext,num+,relsize]
  173. num = initial value
  174. integeraction(info,newnum) {x}
  175. example: [INTEGER,{v},'int:',5,3]
  176.  
  177. [LISTV,action,textabove,relx,rely,execlist+,readbool,selected,current+]
  178. execlist = ptr to an execlist. (see tools/constructors.m)
  179. readbool = whether listview is read-only
  180. *selected = 0=none, 1=read, 2=strgad (fill in 0 for compat.)
  181. listviewaction(info,num_selected) {x,y}
  182. example: [LISTV,0,NIL,5,5,filenamelist,0,NIL,0]
  183.  
  184. [MX,action,abovetext,nil_term_elist,lefttextbool,current]
  185. mxaction(info,num_selected)
  186. example: [MX,{v},NIL,['One','Two','Three',NIL],FALSE,1]
  187.  
  188. [CYCLE,action,lefttext,nil_term_elist,current]
  189. cycleaction(info,num_selected)
  190. example: [CYCLE,{v},'choose:',['Yep','Nope',NIL],1]
  191.  
  192. [PALETTE,action,lefttext,depth,relx,rely]
  193. depth = 1..8, number of bitplanes this color is for
  194. paletteaction(info,colour) {x,y}
  195. example: [PALETTE,{v},'color:',3,5,2]
  196.  
  197. [SCROLL,action,isvert,total+,top+,visible+,relsize]
  198. total = resolution of scroller
  199. top = current top represented
  200. visible = current
  201. scolleraction(info,curtop) {x|y}
  202. example: [SCROLL,{v},FALSE,10,0,2,2]
  203.  
  204. [SLIDE,action,lefttext,isvert,min,max,cur+,relsize,levelformat]
  205. min,max = value range of slider
  206. cur = current value
  207. levelformat = string that shows levelformat, example '%2ld'. leave
  208. a large amount of spaces left in lefttext for this.
  209. slideraction(info,cur) {x|y}
  210. example: [SLIDE,0,'Colors:',FALSE,1,8,3,5,'']
  211.  
  212. [STR,action,lefttext,initial+,maxchars,relsize]
  213. initial = initial string contents: NOTE: HAS TO BE AN ESTRING!
  214. maxchars = max #of chars for string
  215. stringaction(info,newstring) {x}
  216. example: [STR,0,'Pattern',s,200,5]      (DEF s[100]:STRING)
  217.  
  218. [TEXT,text,lefttext,borderbool,relsize] {x}
  219. borderbool = whether or not a recessed bevelbox should be placed around 'text'
  220. example: [TEXT,'Selected Fonts',NIL,FALSE,3]
  221.  
  222. [NUM,int,lefttext,borderbool,relsize] {x}
  223. borderbool: see TEXT
  224. example: [NUM,123,'num:',TRUE,5]
  225.  
  226. [SBUTTON] {x}
  227. same as button, only now resizes horizontally.
  228.  
  229. [PLUGIN,action,plugin_object]
  230. (see seperate chapter 5 on using/implementing these).
  231.  
  232. [BAR], [SPACE] {x,y}, [SPACEH] {x}, [SPACEV] {y}
  233. BAR places a nice divider-bar between gadgets/groups. Whether it's
  234. horizontal or vertical depends on which group it is in. SPACE/SPACEH/SPACEV
  235. do nothing, they only eat up space. This can be very handy in GUI design,
  236. they act like a spring between elements (do not use them on the borders of a
  237. GUI, only in the middle).
  238.  
  239. See the example GUI's how to use these.
  240.  
  241. #?text:
  242. (where #? is left/right etc.): a text to place next to the gadget. often
  243. is allowed to be NIL.
  244.  
  245. relsize,relx,rely:
  246. generally gadgets will automatically get a size depending on a number of
  247. factors, but relsize allows the programmer to give a minimum size for certain
  248. gadgets, thereby sizing a whole group.  If other gadgets already account for
  249. the minimum size, this one can safely be set to a low value such as 2.  All
  250. these sizes are calculated in terms of the _height_ of the font.  Always try
  251. out your GUI with different fonts.  For example if you design a gui that only
  252. just fits horizontally with an 8 point font on 640x200, when run on with a 13
  253. point font on 640x512, the gui will be quite a bit bigger horizontally, but
  254. the screen isn't, so it won't fit.  (see also:  the "bigg" exception below).
  255.  
  256. nil_term_elist:
  257. a nil-terminated E list, such as ['One','Two','Three',NIL]
  258.  
  259. isvert:
  260. TRUE if gadget needs to be vertical, horizontal by default.
  261.  
  262. +---------------------------------------------------------------+
  263. |    3. How Layout Works                    |
  264. +---------------------------------------------------------------+
  265.  
  266. EasyGUI works by automatically layouting the gadgets on the
  267. screen. In a first pass, it will compute the minimum size for
  268. each element: for gadgets this involves the size of fonts and
  269. various other things. For a ROWS list, for example, it will take
  270. the width of the biggest gadget as its width, and computes its
  271. height by adding the heights of all other gadgets. For EQROWS
  272. this is slightly more complicated: EasyGUI also computes a "middle"
  273. for various gadgets, often between the text that denotes what a
  274. gadget is about and the gadget itself. It then tries to align
  275. all of these. for EQCOLS it simply tries to make all columns
  276. equal width.
  277. In a second pass, EasyGUI assigns the final coordinates to all
  278. gadgets. Important to notice is that in a GUI often there is
  279. more space available than is required for a gadget, for example
  280. the gadget above it in a ROWS environment is much wider. Also, the
  281. user may have resized the window. To do something useful with this
  282. space, EasyGUI looks at which gadgets can do something useful
  283. with extra space, such as LISTV, or STR, SCROLL etc. This process
  284. of granting extra space propagates through ROWS/COLS, which act
  285. as gadgets themselves. Gadgets like BUTTON don't benefit from more
  286. space, so they give that away to their neighbours.
  287.  
  288.  
  289. +---------------------------------------------------------------+
  290. |    4. Advanced features                    |
  291. +---------------------------------------------------------------+
  292.  
  293. Throwing exceptions from actionfunctions
  294. ----------------------------------------
  295. is allowed: EasyGUI will catch it, close the window properly,
  296. and then ReThrow() it.
  297.  
  298. exceptions raised by EasyGUI itself:
  299.  
  300. "MEM"   -- no mem
  301. "GUI"   -- for things like CreateGadgetA, OpenWindowTagList etc.
  302. "GT"    -- couldn't open gadtools.library
  303. "bigg"    -- for "BIG Gui": interface is calculated to be bigger than the screen.
  304.        generally you should keep gui's small, so that they still fit on
  305.        640x200 topaz screens. If the user runs Times/30 on a screen this size,
  306.        he probably knows he has a problem.
  307. "Egui"  -- a design error: most probably handed over a list to dogui()
  308.            that was either to long or too short
  309. <other> -- Raise()ed by own function
  310.  
  311. You can also use a "quit" exception or somesuch if you need to quit from an
  312. actionfunction (i.e. other than with an actionvalue).
  313.  
  314.  
  315. Multiple Windows
  316. ----------------
  317. The simplest use of EasyGUI is just by calling easygui(). You can however
  318. open any number of windows, and check messages for all of them.
  319.  
  320.     guiinit(windowtitle,gui,info=0,screen=0,textattr=0,newmenus=0)
  321.     guimessage(guihandle)
  322.     cleangui(guihandle)
  323.  
  324. Call guiinit() for each window (exactly the same arguments as easygui(). Then,
  325. keep calling guimessage() for each of them, when messages arive. you can
  326. close them again with cleangui(), for example when a gui returns a
  327. positive integer (the actioncode). Negative integers signal that it simply
  328. finished processing all messages, but no need to close the window yet.
  329.  
  330. example of usage of these three function (= definition easygui())
  331.  
  332.  
  333.     EXPORT PROC easygui(windowtitle,gui,info=NIL,screen=NIL,textattr=NIL,newmenus=NIL) HANDLE
  334.       DEF gh=NIL:PTR TO guihandle,res=-1
  335.       gh:=guiinit(windowtitle,gui,info,screen,textattr,newmenus)
  336.       WHILE res<0
  337.         Wait(gh.sig)
  338.         res:=guimessage(gh)
  339.       ENDWHILE
  340.     EXCEPT DO
  341.       cleangui(gh)
  342.       ReThrow()
  343.     ENDPROC res
  344.  
  345.  
  346. the object you get has some handy field in there: the window in question,
  347. and the sigmask (i.e. Shl(1,sigbit)), if you want to do a proper Wait()
  348. (OR them).
  349.  
  350.     OBJECT guihandle
  351.       wnd:PTR TO window
  352.       sig:LONG
  353.     ENDOBJECT     /* SIZEOF=64 */
  354.                               ^^^^private!
  355.  
  356. if you want to draw into `wnd': stdrast is automatically set to the last
  357. EasyGUI opened.
  358.  
  359.  
  360. Multiple copies of a GUI
  361. ------------------------
  362. if your app allows to have multiple copies of the _same_ gui open
  363. at the same time (for example if you open windows recursively, or
  364. you use the multiple window technique described above to open more
  365. instances of one GUI), you might need to dynamically allocate the GUI
  366. description, because of the way dynamically computed values are
  367. put into static E lists. A GUI desciption with [] lists is static,
  368. i.e. only allocated once. Adding NEW to all of them is hard to deallocate,
  369. and this is where disposegui() comes in. To safely use this feature,
  370. allocate ALL lists belonging to the GUI desciption dynamically with
  371. NEW [...] (this does not include lists such as the one used for the
  372. various labels in CYCLE-gadgets).
  373.  
  374.     easygui('Bla',
  375.           gui:=NEW [ROWS,
  376.              NEW [STR,{str},'input:',s,50,4],
  377.                  NEW [CYCLE,{cycle},'choose:',['Yep','Nope',NIL],1]])
  378.     disposegui(gui)
  379.  
  380. Call disposegui() with the top-level list. on each gadget-list (i.e.
  381. NEW [CYCLE,...]) it will simply call FastDisposeList(), on COLS and
  382. ROWS etc. it will first deallocate each element recursively.
  383.  
  384.  
  385. Manipulating Gadgets
  386. --------------------
  387. [currently, this assumes you're using the DIY version of EasyGUI (as
  388.  described under "multiple windows".]
  389. You might need to modify gadgets while a GUI is active, for example
  390. to set a slider when a corresponding integer gadget is modified by
  391. the user, or to change the contents of a listview.
  392.  
  393. You can denote gadgets to change by simply storing their addresses,
  394. i.e.:
  395.  
  396.     [COLS,
  397.       mygad:=[CHECK,....],
  398.           ...
  399.         ]
  400.  
  401. Now you can use `mygad' with some of the functions below. Note that,
  402. of course `mygad' isn't a gadget, but it helps EasyGUI to find the
  403. real gadget.
  404.  
  405.     setscrollvisible(gh,gad,visible)
  406.     setscrolltop(gh,gad,top)
  407.     setscrolltotal(gh,gad,total)
  408.     setlistvselected(gh,gad,active)
  409.     setlistvlabels(gh,gad,labs)
  410.     setinteger(gh,gad,new)
  411.     setcycle(gh,gad,active)
  412.     setmx(gh,gad,active)
  413.     setstr(gh,gad,new)
  414.     setslide(gh,gad,new)
  415.     setcheck(gh,gad,bool)
  416.     settext(gh,gad,newtext)
  417.     setnum(gh,gad,newnum)
  418.  
  419. for all these: `gh' is the gui you're talking about (as returned from
  420. guiinit()), `gad' is a value that denotes the gadget as described above.
  421. the third value is whatever you're changing about the gadget. Note that
  422. in doing so, you need to respect usual restrictions on gadtools gadgets,
  423. for example setlistlables() requires that you first set it to -1, then
  424. modify the list, and put it back.
  425.  
  426.     realgadget:=findgadget(gh,list)
  427.  
  428. allows you to find the gadget address, for all those modifications
  429. that aren't possible with the above set#? functions. It returns an intuition
  430. gadget structure. Note that preferably you will want to use the set#?
  431. functions, as these cooperate with EasyGUI very well (in keeping
  432. track of the current value, for example: setstr() also copies the new
  433. value to the estring you attached to the gadget).
  434.  
  435.  
  436. Topaz Fallback
  437. --------------
  438. the function `easygui_fallback()' is equivalent to `easygui()' apart from the
  439. fact that when EasyGUI fails with the "bigg" exception, it will try again with
  440. topaz-8.  Note that you should never want to rely on topaz, this function was
  441. only added for emergency situations.  If your GUI is too big on some systems,
  442. you should redesign your GUI to fit comfortably instead.  (see other parts of
  443. this doc that talk about GUI-size and testing).
  444.  
  445.  
  446. +---------------------------------------------------------------+
  447. |    5. PLUGINs                        |
  448. +---------------------------------------------------------------+
  449.  
  450. PLUGINs allow the programmer to extend EasyGUI with new functionality, i.e.
  451. to add any kind of rendering/gadgets to the GUI, while cooperating
  452. automatically with EasyGUI's layout/resizing.  You can use plugins to add
  453. rendering areas in the midst of EasyGUI gadgetry (e.g.  for graphics
  454. programs), add BOOPSI gadgets to a GUIs etc.  You can supply ready-made
  455. plugins for other programmers to use.
  456.  
  457. Any PLUGIN is an object inherited from the 'plugin' object found in easygui.m.
  458. To implement a new plugin all that needs to be done is redefine a few methods.
  459. Then, this PLUGIN can be plugged in to any EasyGUI with for example:
  460.  
  461.     [PLUGIN,{plugaction},NEW mp.myplugin()]
  462.  
  463. in your GUI-spec. Wether the action-value is used depends on the PLUGIN, as
  464. we'll see below.
  465.  
  466. Have a quick look at the plugin example sources, or keep them handy while
  467. reading the bit below.
  468.  
  469. Creating the object
  470. -------------------
  471. create your new object as a 'plugin'-subtype.  You may add constructors/
  472. destructors if you wish.  following methods implement the plugins behaviour,
  473. and may be redefined:
  474.  
  475.     will_resize()
  476.  
  477. is called once just before the window is opened.  You should return a flag-set
  478. telling in which ways your object can resize, making use of the constants
  479. RESIZEX and RESIZEY, 0 of course meaning your object is fixed in size (default
  480. method returns RESIZEX OR RESIZEY, i.e.  resize in both directions).
  481.  
  482.     min_size(fontheight)
  483.  
  484. is called once just before the window is opened.  you should return the
  485. _minimum_ x and y sizes of your PLUGIN as _two_ returnvalues, making use of
  486. `fontheight' if you wish.  Note that EasyGUI may actually grant you a lot more
  487. space than just the minimum space you ask for, depending on the other gadgets
  488. and user-resizing.  If your object can have al sorts of sizes, pick a
  489. relatively small one as minimum.  The default method just returns
  490. (fontheight,fontheight)
  491.  
  492.     render(x,y,xs,ys,win:PTR TO window)
  493.  
  494. Here you should render your object to the window.  In the case of a gadget
  495. this means creating the gadget and attaching it to the window (AddGList(),
  496. RefreshGList(), make sure you render only your own gadget(s)).  (xs,ys) is
  497. always at least the minimum size you asked for.  (x,y,xs,ys) is also copied to
  498. your object before this method is called, for use in other methods).  The
  499. default method paints a nice black box :-)
  500.  
  501.     clear_render(win:PTR TO window)
  502.  
  503. mainly useful for gadgets to remove the gadget from the window and free it
  504. (RemoveGList(), remove only your own gadget(s)!).  Normally render() is called
  505. when the window opens, and clear_render() when the window closes, when the
  506. user resizes, however, clear_render() and render() are called one after
  507. another, in that order, to account for the changed window layout.  The default
  508. method does nothing.
  509.  
  510.     message_test(imsg:PTR TO intuimessage,win:PTR TO window)
  511.  
  512. is phase-1 of the message handling, splitted in two to not block intuition too
  513. much.  In message_test() the only thing you should do is return TRUE _only_if_
  514. the intuimessage is meant for your object, otherwise FALSE.  You may test for
  515. example GADGETUP/MOUSEBUTTON/MOUSEMOVE, which are all set by EasyGUI.  For a
  516. mouse-click, test if it was in your area (the current dimensions of your
  517. object in the GUI are present in the `plugin' object), for gadgets, make sure
  518. it is really your gadget causing the message (check .iaddress).  If you reply
  519. TRUE to messages that are potentially meant for other objects, you might choke
  520. them.  Do not engage in other actions in this method, such as rendering.  The
  521. default method returns FALSE.
  522.  
  523.     message_action(win:PTR TO window)
  524.  
  525. is the second part, and will only be called if you returned TRUE in the
  526. previous method.  here you may do any action needed (additional rendering
  527. based on the user action).  You should return TRUE if you want the action the
  528. user of the PLUGIN has written in his GUI-spec to be executed upon termination
  529. of this method (do this if your object clearly can be "hit", such as a gadget.
  530. If you just do some rendering you might want to ignore the actionvalue).  The
  531. default method returns FALSE.
  532.  
  533. Note:  do not confuse message_action() with action values:  the former is for
  534. implementing the plugin's behaviour generally, while the latter is for
  535. specific behaviour in a specific GUI, attached by the user of your plugin
  536. (which could be you again :-).
  537.  
  538. If you supply a plugin as module for others, you'll have to state what
  539. constructor(s) they may use, wether or not they have to supply a sensible
  540. action-value.  END will almost always have to be called.
  541.  
  542.  
  543. +---------------------------------------------------------------+
  544. |    6. bugs/future                        |
  545. +---------------------------------------------------------------+
  546.  
  547. bugs:
  548. - method of displaying slider values not bulletproof
  549. - sometimes problems with finding correct size for gadgets with a
  550.   lefttext in an EQROWS
  551. - the MX gadget does not use the "abovetext" field
  552.  
  553. future:
  554. - support GTLV_SHOWSELECTED
  555. - maybe supply a host of handy plugins as standard (for images / image gadgets
  556.   / various boopsi gadgets etc.)
  557. - key presses?
  558. - easy blocking (for now, look at the JRH's RKRM intuition/requesters_alerts/
  559.   blockinput.e if you need this) [in general: try to design your GUIs such
  560.   that the user can use them all simultaneously, this is much friendlier]
  561.  
  562. [the planned render spaces can now be done much better by using PLUGINs]
  563.  
  564.  
  565. ----------------------------------------------------------------
  566.  
  567. General advice:  try out and modify the examples.  Sometimes something won't
  568. work, but EasyGUI is flexible enough that at least one way of arranging groups
  569. etc.  will give you a nice GUI :-).  If you need more power than EasyGUI
  570. currently gives, you'll have to use MUI/BGUI/WhatEver instead.
  571.  
  572. Wouter
  573.  
  574.